package com.zbangmall.util.image;


import com.zbangmall.util.common.FileUtil;

import javax.imageio.ImageIO;
import javax.imageio.ImageReadParam;
import javax.imageio.ImageReader;
import javax.imageio.stream.ImageInputStream;
import java.awt.*;
import java.awt.color.ColorSpace;
import java.awt.image.BufferedImage;
import java.awt.image.ColorConvertOp;
import java.io.*;
import java.util.Iterator;
import java.util.List;

/**
 * 图片相关的操作
 */
public final class OperateImage {
	/**
	 * 图形交换格式
	 */
	public static String IMAGE_TYPE_GIF  = "gif";
	/**
	 * 联合照片专家组
	 */
	public static String IMAGE_TYPE_JPG  = "jpg";
	/**
	 * 联合照片专家组
	 */
	public static String IMAGE_TYPE_JPEG = "jpeg";
	/**
	 * 英文Bitmap（位图）的简写，它是Windows操作系统中的标准图像文件格式
	 */
	public static String IMAGE_TYPE_BMP  = "bmp";
	/**
	 * 可移植网络图形
	 */
	public static String IMAGE_TYPE_PNG  = "png";
	/**
	 * Photoshop的专用格式Photoshop
	 */
	public static String IMAGE_TYPE_PSD  = "psd";

	/**
	 * 对图片裁剪，并把裁剪新图片保存
	 *
	 * @param srcPath          读取源图片路径
	 * @param toPath           写入图片路径
	 * @param x                剪切起始点x坐标
	 * @param y                剪切起始点y坐标
	 * @param width            剪切宽度
	 * @param height           剪切高度
	 * @param readImageFormat  读取图片格式
	 * @param writeImageFormat 写入图片格式
	 * @throws IOException
	 */
	public static void cropImage(String srcPath, String toPath,
								 int x, int y, int width, int height,
								 String readImageFormat, String writeImageFormat) throws IOException {
		try (
				FileInputStream fis = new FileInputStream(srcPath);
				ImageInputStream iis = ImageIO.createImageInputStream(fis)
		) {
			Iterator    it     = ImageIO.getImageReadersByFormatName(readImageFormat);
			ImageReader reader = (ImageReader) it.next();
			//获取图片流
			reader.setInput(iis, true);
			ImageReadParam param = reader.getDefaultReadParam();
			//定义一个矩形
			Rectangle rect = new Rectangle(x, y, width, height);
			//提供一个 BufferedImage，将其用作解码像素数据的目标。
			param.setSourceRegion(rect);
			BufferedImage bi = reader.read(0, param);
			//保存新图片
			ImageIO.write(bi, writeImageFormat, new File(toPath));
		} catch (IOException e) {
			e.printStackTrace();
			throw e;
		}
	}

	/**
	 * 按倍率缩小图片
	 *
	 * @param srcImagePath 读取图片路径
	 * @param toImagePath  写入图片路径
	 * @param widthRatio   宽度缩小比例
	 * @param heightRatio  高度缩小比例
	 * @throws IOException
	 */
	public static void reduceImageByRatio(String srcImagePath, String toImagePath, int widthRatio, int heightRatio) throws IOException {
		File file = new File(srcImagePath);
		try (FileOutputStream out = new FileOutputStream(toImagePath)) {
			//读入文件

			String prefix = FileUtil.suffix(file);
			// 构造Image对象
			BufferedImage srcBuffer = ImageIO.read(file);
			// 按比例缩减图像
			BufferedImage imageBuffer = ImageUtil.imageShrinkRatio(srcBuffer, widthRatio, heightRatio);
			ImageIO.write(imageBuffer, prefix, out);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * 长高等比例缩小图片
	 *
	 * @param srcImagePath 读取图片路径
	 * @param toImagePath  写入图片路径
	 * @param ratio        缩小比例
	 * @throws IOException
	 */
	public static void reduceImageEqualProportion(String srcImagePath, String toImagePath, int ratio) throws IOException {
		File file = new File(srcImagePath);
		try (FileOutputStream out = new FileOutputStream(toImagePath)) {
			//读入文件
			String prefix = FileUtil.suffix(file);
			// 构造Image对象
			BufferedImage srcBuffer = ImageIO.read(file);
			// 按比例缩减图像
			BufferedImage imageBuffer = ImageUtil.imageShrinkRatio(srcBuffer, ratio, ratio);
			ImageIO.write(imageBuffer, prefix, out);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * 按倍率放大图片
	 *
	 * @param srcImagePath 读取图形路径
	 * @param toImagePath  写入入行路径
	 * @param widthRatio   宽度放大比例
	 * @param heightRatio  高度放大比例
	 * @throws IOException
	 */
	public static void enlargementImageByRatio(String srcImagePath, String toImagePath, int widthRatio, int heightRatio) throws IOException {
		File file = new File(srcImagePath);
		try (FileOutputStream out = new FileOutputStream(toImagePath)) {
			//读入文件
			String prefix = FileUtil.suffix(file);
			// 构造Image对象
			BufferedImage srcBuffer = ImageIO.read(file);
			// 按比例缩减图像
			BufferedImage imageBuffer = ImageUtil.imageMagnifyRatio(srcBuffer, widthRatio, heightRatio);
			ImageIO.write(imageBuffer, prefix, out);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}


	/**
	 * 长高等比例放大图片
	 *
	 * @param srcImagePath 读取图形路径
	 * @param toImagePath  写入入行路径
	 * @param ratio        放大比例
	 * @throws IOException
	 */
	public static void enlargementImageEqualProportion(String srcImagePath, String toImagePath, int ratio) throws IOException {
		File file = new File(srcImagePath);
		try (FileOutputStream out = new FileOutputStream(toImagePath)) {
			//读入文件
			String prefix = FileUtil.suffix(file);
			// 构造Image对象
			BufferedImage srcBuffer = ImageIO.read(file);
			// 按比例缩减图像
			BufferedImage imageBuffer = ImageUtil.imageMagnifyRatio(srcBuffer, ratio, ratio);
			ImageIO.write(imageBuffer, prefix, out);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * 重置图形的边长大小
	 *
	 * @param srcImagePath 原图像
	 * @param toImagePath  新生产的图像
	 * @param width        图像宽度
	 * @param height       图像高度
	 * @throws IOException
	 */
	public static void resizeImage(String srcImagePath, String toImagePath, int width, int height) throws IOException {
		File file = new File(srcImagePath);
		try (FileOutputStream out = new FileOutputStream(toImagePath)) {
			//读入文件
			String prefix = FileUtil.suffix(file);
			// 构造Image对象
			BufferedImage srcBuffer = ImageIO.read(file);
			// 按比例缩减图像
			BufferedImage imageBuffer = ImageUtil.imageResize(srcBuffer, width, height);
			ImageIO.write(imageBuffer, prefix, out);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * 横向拼接图片（两张）
	 *
	 * @param firstSrcImagePath  第一张图片的路径
	 * @param secondSrcImagePath 第二张图片的路径
	 * @param imageFormat        拼接生成图片的格式
	 * @param toPath             拼接生成图片的路径
	 *                           要拼接的俩张图片尺寸要一致
	 */
	public static void joinImagesHorizontal(String firstSrcImagePath, String secondSrcImagePath, String imageFormat, String toPath) {
		try {
			//读取第一张图片
			File          fileOne  = new File(firstSrcImagePath);
			BufferedImage imageOne = ImageIO.read(fileOne);
			//图片宽度
			int width = imageOne.getWidth();
			//图片高度
			int height = imageOne.getHeight();
			//从图片中读取RGB
			int[] imageArrayOne = new int[width * height];
			imageArrayOne = imageOne.getRGB(0, 0, width, height, imageArrayOne, 0, width);

			//对第二张图片做相同的处理
			File          fileTwo       = new File(secondSrcImagePath);
			BufferedImage imageTwo      = ImageIO.read(fileTwo);
			int           width2        = imageTwo.getWidth();
			int           height2       = imageTwo.getHeight();
			int[]         ImageArrayTwo = new int[width2 * height2];
			ImageArrayTwo = imageTwo.getRGB(0, 0, width, height, ImageArrayTwo, 0, width);

			//生成新图片
			BufferedImage imageNew = new BufferedImage(width * 2, height, BufferedImage.TYPE_INT_RGB);
			//BufferedImage  imageNew  =  new  BufferedImage(width+width2,height3,BufferedImage.TYPE_INT_RGB);
			//设置左半部分的RGB
			imageNew.setRGB(0, 0, width, height, imageArrayOne, 0, width);
			//设置右半部分的RGB
			imageNew.setRGB(width, 0, width, height, ImageArrayTwo, 0, width);

			File outFile = new File(toPath);
			//写图片
			ImageIO.write(imageNew, imageFormat, outFile);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * 横向拼接一组（多张）图像
	 *
	 * @param pics    将要拼接的图像
	 * @param type    图像写入格式
	 * @param dst_pic 图像写入路径
	 * @return
	 */
	public static boolean joinImageListHorizontal(String[] pics, String type, String dst_pic) {
		try {
			int len = pics.length;
			if (len < 1) {
				System.out.println("pics len < 1");
				return false;
			}
			File[]          src         = new File[len];
			BufferedImage[] images      = new BufferedImage[len];
			int[][]         imageArrays = new int[len][];
			for (int i = 0; i < len; i++) {
				src[i] = new File(pics[i]);
				images[i] = ImageIO.read(src[i]);
				int width  = images[i].getWidth();
				int height = images[i].getHeight();
				// 从图片中读取RGB
				imageArrays[i] = new int[width * height];
				imageArrays[i] = images[i].getRGB(0, 0, width, height, imageArrays[i], 0, width);
			}

			int dst_width  = 0;
			int dst_height = images[0].getHeight();
			for (int i = 0; i < images.length; i++) {
				dst_height = dst_height > images[i].getHeight() ? dst_height : images[i].getHeight();
				dst_width += images[i].getWidth();
			}
			if (dst_height < 1) {
				System.out.println("dst_height < 1");
				return false;
			}
			/*
             * 生成新图片
             */
			BufferedImage ImageNew = new BufferedImage(dst_width, dst_height, BufferedImage.TYPE_INT_RGB);
			int           width_i  = 0;
			for (int i = 0; i < images.length; i++) {
				ImageNew.setRGB(width_i, 0, images[i].getWidth(), dst_height, imageArrays[i], 0, images[i].getWidth());
				width_i += images[i].getWidth();
			}
			File outFile = new File(dst_pic);
			ImageIO.write(ImageNew, type, outFile);
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
		return true;
	}

	/**
	 * 纵向拼接图片（两张）
	 *
	 * @param firstSrcImagePath  读取的第一张图片
	 * @param secondSrcImagePath 读取的第二张图片
	 * @param imageFormat        图片写入格式
	 * @param toPath             图片写入路径
	 */
	public static void joinImagesVertical(String firstSrcImagePath, String secondSrcImagePath, String imageFormat, String toPath) {
		try {
			//读取第一张图片
			File          fileOne  = new File(firstSrcImagePath);
			BufferedImage imageOne = ImageIO.read(fileOne);
			//图片宽度
			int width = imageOne.getWidth();
			//图片高度
			int height = imageOne.getHeight();
			//从图片中读取RGB
			int[] imageArrayOne = new int[width * height];
			imageArrayOne = imageOne.getRGB(0, 0, width, height, imageArrayOne, 0, width);

			//对第二张图片做相同的处理
			File          fileTwo       = new File(secondSrcImagePath);
			BufferedImage imageTwo      = ImageIO.read(fileTwo);
			int           width2        = imageTwo.getWidth();
			int           height2       = imageTwo.getHeight();
			int[]         ImageArrayTwo = new int[width2 * height2];
			ImageArrayTwo = imageTwo.getRGB(0, 0, width, height, ImageArrayTwo, 0, width);

			//生成新图片
			BufferedImage imageNew = new BufferedImage(width, height * 2, BufferedImage.TYPE_INT_RGB);
			//设置上半部分的RGB
			imageNew.setRGB(0, 0, width, height, imageArrayOne, 0, width);
			//设置下半部分的RGB
			imageNew.setRGB(0, height, width, height, ImageArrayTwo, 0, width);

			File outFile = new File(toPath);
			ImageIO.write(imageNew, imageFormat, outFile);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * 纵向拼接一组（多张）图像
	 *
	 * @param pics    将要拼接的图像数组
	 * @param type    写入图像类型
	 * @param dst_pic 写入图像路径
	 * @return
	 */
	public static boolean joinImageListVertical(String[] pics, String type, String dst_pic) {
		try {
			int len = pics.length;
			if (len < 1) {
				System.out.println("pics len < 1");
				return false;
			}
			File[]          src         = new File[len];
			BufferedImage[] images      = new BufferedImage[len];
			int[][]         imageArrays = new int[len][];
			for (int i = 0; i < len; i++) {
				//System.out.println(i);
				src[i] = new File(pics[i]);
				images[i] = ImageIO.read(src[i]);
				int width  = images[i].getWidth();
				int height = images[i].getHeight();
				imageArrays[i] = new int[width * height];// 从图片中读取RGB
				imageArrays[i] = images[i].getRGB(0, 0, width, height, imageArrays[i], 0, width);
			}

			int dst_height = 0;
			int dst_width  = images[0].getWidth();
			for (int i = 0; i < images.length; i++) {
				dst_width = dst_width > images[i].getWidth() ? dst_width : images[i].getWidth();
				dst_height += images[i].getHeight();
			}
			//System.out.println(dst_width);
			//System.out.println(dst_height);
			if (dst_height < 1) {
				System.out.println("dst_height < 1");
				return false;
			}
            /*
             * 生成新图片
             */
			BufferedImage ImageNew = new BufferedImage(dst_width, dst_height, BufferedImage.TYPE_INT_RGB);
			int           height_i = 0;
			for (int i = 0; i < images.length; i++) {
				ImageNew.setRGB(0, height_i, dst_width, images[i].getHeight(), imageArrays[i], 0, dst_width);
				height_i += images[i].getHeight();
			}
			File outFile = new File(dst_pic);
			ImageIO.write(ImageNew, type, outFile);// 写图片
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
		return true;
	}

	/**
	 * 合并图片(按指定初始x、y坐标将附加图片贴到底图之上)
	 *
	 * @param negativeImagePath 背景图片路径
	 * @param additionImagePath 附加图片路径
	 * @param x                 附加图片的起始点x坐标
	 * @param y                 附加图片的起始点y坐标
	 * @param toPath            图片写入路径
	 * @throws IOException
	 */
	public static void mergeBothImage(String negativeImagePath, String additionImagePath, String iamgeFromat, int x, int y, String toPath) throws IOException {
		InputStream  is  = null;
		InputStream  is2 = null;
		OutputStream os  = null;
		try {
			is = new FileInputStream(negativeImagePath);
			is2 = new FileInputStream(additionImagePath);
			BufferedImage image  = ImageIO.read(is);
			BufferedImage image2 = ImageIO.read(is2);
			Graphics      g      = image.getGraphics();
			g.drawImage(image2, x, y, null);
			os = new FileOutputStream(toPath);
			ImageIO.write(image, iamgeFromat, os);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if (os != null) {
				os.close();
			}
			if (is2 != null) {
				is2.close();
			}
			if (is != null) {
				is.close();
			}
		}
	}

	/**
	 * 将一组图片一次性附加合并到底图上
	 *
	 * @param negativeImagePath 源图像（底图）路径
	 * @param additionImageList 附加图像信息列表
	 * @param imageFormat       图像写入格式
	 * @param toPath            图像写入路径
	 * @throws IOException
	 */
	public static void mergeImageList(String negativeImagePath, List additionImageList, String imageFormat, String toPath) throws IOException {
		InputStream  is  = null;
		InputStream  is2 = null;
		OutputStream os  = null;
		try {
			is = new FileInputStream(negativeImagePath);
			BufferedImage image = ImageIO.read(is);
			//Graphics g=image.getGraphics();
			Graphics2D    g      = image.createGraphics();
			BufferedImage image2 = null;
			if (additionImageList != null) {
				for (int i = 0; i < additionImageList.size(); i++) {
					//解析附加图片信息：x坐标、 y坐标、 additionImagePath附加图片路径
					//图片信息存储在一个数组中
					String[] additionImageInfo = (String[]) additionImageList.get(i);
					int      x                 = Integer.parseInt(additionImageInfo[0]);
					int      y                 = Integer.parseInt(additionImageInfo[1]);
					String   additionImagePath = additionImageInfo[2];
					//读取文件输入流，并合并图片
					is2 = new FileInputStream(additionImagePath);
					//System.out.println(x+"  :  "+y+"  :  "+additionImagePath);
					image2 = ImageIO.read(is2);
					g.drawImage(image2, x, y, null);
				}
			}
			os = new FileOutputStream(toPath);
			ImageIO.write(image, imageFormat, os);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if (os != null) {
				os.close();
			}
			if (is2 != null) {
				is2.close();
			}
			if (is != null) {
				is.close();
			}
		}
	}


	/**
	 * 图片灰化操作
	 *
	 * @param srcImage    读取图片路径
	 * @param toPath      写入灰化后的图片路径
	 * @param imageFormat 图片写入格式
	 */
	public static void grayImage(String srcImage, String toPath, String imageFormat) {
		try {
			BufferedImage  src = ImageIO.read(new File(srcImage));
			ColorSpace     cs  = ColorSpace.getInstance(ColorSpace.CS_GRAY);
			ColorConvertOp op  = new ColorConvertOp(cs, null);
			src = op.filter(src, null);
			ImageIO.write(src, imageFormat, new File(toPath));
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * 在源图片上设置水印文字
	 *
	 * @param srcImagePath 源图片路径
	 * @param alpha        透明度（0<alpha<1）
	 * @param font         字体（例如：宋体）
	 * @param fontStyle    字体格式(例如：普通样式--Font.PLAIN、粗体--Font.BOLD )
	 * @param fontSize     字体大小
	 * @param color        字体颜色(例如：黑色--Color.BLACK)
	 * @param inputWords   输入显示在图片上的文字
	 * @param x            文字显示起始的x坐标
	 * @param y            文字显示起始的y坐标
	 * @param imageFormat  写入图片格式（png/jpg等）
	 * @param toPath       写入图片路径
	 * @throws IOException
	 */
	public static void alphaWords2Image(String srcImagePath, float alpha,
										String font, int fontStyle, int fontSize, Color color,
										String inputWords, int x, int y, String imageFormat, String toPath) throws IOException {
		FileOutputStream fos = null;
		try {
			BufferedImage image = ImageIO.read(new File(srcImagePath));
			//创建java2D对象
			Graphics2D g2d = image.createGraphics();
			//用源图像填充背景
			g2d.drawImage(image, 0, 0, image.getWidth(), image.getHeight(), null, null);
			//设置透明度
			AlphaComposite ac = AlphaComposite.getInstance(AlphaComposite.SRC_OVER, alpha);
			g2d.setComposite(ac);
			//设置文字字体名称、样式、大小
			g2d.setFont(new Font(font, fontStyle, fontSize));
			//设置字体颜色
			g2d.setColor(color);
			//输入水印文字及其起始x、y坐标
			g2d.drawString(inputWords, x, y);
			g2d.dispose();
			fos = new FileOutputStream(toPath);
			ImageIO.write(image, imageFormat, fos);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if (fos != null) {
				fos.close();
			}
		}
	}

	/**
	 * 在源图像上设置图片水印
	 * ---- 当alpha==1时文字不透明（和在图片上直接输入文字效果一样）
	 *
	 * @param srcImagePath    源图片路径
	 * @param appendImagePath 水印图片路径
	 * @param alpha           透明度
	 * @param x               水印图片的起始x坐标
	 * @param y               水印图片的起始y坐标
	 * @param width           水印图片的宽度
	 * @param height          水印图片的高度
	 * @param imageFormat     图像写入图片格式
	 * @param toPath          图像写入路径
	 * @throws IOException
	 */
	public static void alphaImage2Image(String srcImagePath, String appendImagePath,
										float alpha, int x, int y, int width, int height,
										String imageFormat, String toPath) throws IOException {
		FileOutputStream fos = null;
		try {
			BufferedImage image = ImageIO.read(new File(srcImagePath));
			//创建java2D对象
			Graphics2D g2d = image.createGraphics();
			//用源图像填充背景
			g2d.drawImage(image, 0, 0, image.getWidth(), image.getHeight(), null, null);
			//设置透明度
			AlphaComposite ac = AlphaComposite.getInstance(AlphaComposite.SRC_OVER, alpha);
			g2d.setComposite(ac);
			//设置水印图片的起始x/y坐标、宽度、高度
			BufferedImage appendImage = ImageIO.read(new File(appendImagePath));
			g2d.drawImage(appendImage, x, y, width, height, null, null);
			g2d.dispose();
			fos = new FileOutputStream(toPath);
			ImageIO.write(image, imageFormat, fos);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if (fos != null) {
				fos.close();
			}
		}
	}

	/**
	 * 画单点 ---- 实际上是画一个填充颜色的圆
	 * ---- 以指定点坐标为中心画一个小半径的圆形，并填充其颜色来充当点
	 *
	 * @param srcImagePath 源图片颜色
	 * @param x            点的x坐标
	 * @param y            点的y坐标
	 * @param width        填充的宽度
	 * @param height       填充的高度
	 * @param ovalColor    填充颜色
	 * @param imageFormat  写入图片格式
	 * @param toPath       写入路径
	 * @throws IOException
	 */
	public static void drawPoint(String srcImagePath, int x, int y, int width, int height, Color ovalColor, String imageFormat, String toPath) throws IOException {
		FileOutputStream fos = null;
		try {
			//获取源图片
			BufferedImage image = ImageIO.read(new File(srcImagePath));
			//根据xy点坐标绘制连接线
			Graphics2D g2d = image.createGraphics();
			g2d.setColor(ovalColor);
			//填充一个椭圆形
			g2d.fillOval(x, y, width, height);
			fos = new FileOutputStream(toPath);
			ImageIO.write(image, imageFormat, fos);
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (fos != null) {
				fos.close();
			}
		}
	}

	/**
	 * 画一组（多个）点---- 实际上是画一组（多个）填充颜色的圆
	 * ---- 以指定点坐标为中心画一个小半径的圆形，并填充其颜色来充当点
	 *
	 * @param srcImagePath 原图片路径
	 * @param pointList    点列表
	 * @param width        宽度
	 * @param height       高度
	 * @param ovalColor    填充颜色
	 * @param imageFormat  写入图片颜色
	 * @param toPath       写入路径
	 * @throws IOException
	 */
	public static void drawPoints(String srcImagePath, List pointList, int width, int height, Color ovalColor, String imageFormat, String toPath) throws IOException {
		FileOutputStream fos = null;
		try {
			//获取源图片
			BufferedImage image = ImageIO.read(new File(srcImagePath));
			//根据xy点坐标绘制连接线
			Graphics2D g2d = image.createGraphics();
			g2d.setColor(ovalColor);
			//填充一个椭圆形
			if (pointList != null) {
				for (int i = 0; i < pointList.size(); i++) {
					Point point = (Point) pointList.get(i);
					int   x     = (int) point.getX();
					int   y     = (int) point.getY();
					g2d.fillOval(x, y, width, height);
				}
			}
			fos = new FileOutputStream(toPath);
			ImageIO.write(image, imageFormat, fos);
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (fos != null) {
				fos.close();
			}
		}
	}

	/**
	 * 画线段
	 *
	 * @param srcImagePath 源图片路径
	 * @param x1           第一个点x坐标
	 * @param y1           第一个点y坐标
	 * @param x2           第二个点x坐标
	 * @param y2           第二个点y坐标
	 * @param lineColor    线条颜色
	 * @param toPath       图像写入路径
	 * @param imageFormat  图像写入格式
	 * @throws IOException
	 */
	public static void drawLine(String srcImagePath, int x1, int y1, int x2, int y2, Color lineColor, String toPath, String imageFormat) throws IOException {
		FileOutputStream fos = null;
		try {
			//获取源图片
			BufferedImage image = ImageIO.read(new File(srcImagePath));
			//根据xy点坐标绘制连接线
			Graphics2D g2d = image.createGraphics();
			g2d.setColor(lineColor);
			g2d.drawLine(x1, y1, x2, y2);
			fos = new FileOutputStream(toPath);
			ImageIO.write(image, imageFormat, fos);
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (fos != null) {
				fos.close();
			}
		}
	}

	/**
	 * 画折线 / 线段
	 * ---- 2个点即画线段，多个点画折线
	 *
	 * @param srcImagePath 源图片路径
	 * @param xPoints      x坐标数组
	 * @param yPoints      y坐标数组
	 * @param nPoints      点的数量
	 * @param lineColor    线条颜色
	 * @param toPath       图像写入路径
	 * @param imageFormat  图片写入格式
	 * @throws IOException
	 */
	public static void drawPolyline(String srcImagePath, int[] xPoints, int[] yPoints, int nPoints, Color lineColor, String toPath, String imageFormat) throws IOException {
		FileOutputStream fos = null;
		try {
			//获取源图片
			BufferedImage image = ImageIO.read(new File(srcImagePath));
			//根据xy点坐标绘制连接线
			Graphics2D g2d = image.createGraphics();
			//设置线条颜色
			g2d.setColor(lineColor);
			g2d.drawPolyline(xPoints, yPoints, nPoints);
			//图像写出路径
			fos = new FileOutputStream(toPath);
			ImageIO.write(image, imageFormat, fos);
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (fos != null) {
				fos.close();
			}
		}
	}

	/**
	 * 绘制折线，并突出显示转折点
	 *
	 * @param srcImagePath 源图片路径
	 * @param xPoints      x坐标数组
	 * @param yPoints      y坐标数组
	 * @param nPoints      点的数量
	 * @param lineColor    连线颜色
	 * @param width        点的宽度
	 * @param height       点的高度
	 * @param ovalColor    点的填充颜色
	 * @param toPath       图像写入路径
	 * @param imageFormat  图像写入格式
	 * @throws IOException
	 */
	public static void drawPolylineShowPoints(String srcImagePath, int[] xPoints, int[] yPoints, int nPoints, Color lineColor, int width, int height, Color ovalColor, String toPath, String imageFormat) throws IOException {
		FileOutputStream fos = null;
		try {
			//获取源图片
			BufferedImage image = ImageIO.read(new File(srcImagePath));
			//根据xy点坐标绘制连接线
			Graphics2D g2d = image.createGraphics();
			//设置线条颜色
			g2d.setColor(lineColor);
			//画线条
			g2d.drawPolyline(xPoints, yPoints, nPoints);
			//设置圆点颜色
			g2d.setColor(ovalColor);
			//画圆点
			if (xPoints != null) {
				for (int i = 0; i < xPoints.length; i++) {
					int x = xPoints[i];
					int y = yPoints[i];
					g2d.fillOval(x, y, width, height);
				}
			}
			//图像写出路径
			fos = new FileOutputStream(toPath);
			ImageIO.write(image, imageFormat, fos);
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (fos != null) {
				fos.close();
			}
		}
	}


	/**
	 * 绘制一个由 x 和 y 坐标数组定义的闭合多边形
	 *
	 * @param srcImagePath 源图片路径
	 * @param xPoints      x坐标数组
	 * @param yPoints      y坐标数组
	 * @param nPoints      坐标点的个数
	 * @param polygonColor 线条颜色
	 * @param imageFormat  图像写入格式
	 * @param toPath       图像写入路径
	 * @throws IOException
	 */
	public static void drawPolygon(String srcImagePath, int[] xPoints, int[] yPoints, int nPoints, Color polygonColor, String imageFormat, String toPath) throws IOException {
		FileOutputStream fos = null;
		try {
			//获取图片
			BufferedImage image = ImageIO.read(new File(srcImagePath));
			//根据xy点坐标绘制闭合多边形
			Graphics2D g2d = image.createGraphics();
			g2d.setColor(polygonColor);
			g2d.drawPolygon(xPoints, yPoints, nPoints);
			fos = new FileOutputStream(toPath);
			ImageIO.write(image, imageFormat, fos);
			g2d.dispose();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if (fos != null) {
				fos.close();
			}
		}
	}

	/**
	 * 绘制并填充多边形
	 *
	 * @param srcImagePath 源图像路径
	 * @param xPoints      x坐标数组
	 * @param yPoints      y坐标数组
	 * @param nPoints      坐标点个数
	 * @param polygonColor 多边形填充颜色
	 * @param alpha        多边形部分透明度
	 * @param imageFormat  写入图形格式
	 * @param toPath       写入图形路径
	 * @throws IOException
	 */
	public static void drawAndAlphaPolygon(String srcImagePath, int[] xPoints, int[] yPoints, int nPoints, Color polygonColor, float alpha, String imageFormat, String toPath) throws IOException {
		FileOutputStream fos = null;
		try {
			//获取图片
			BufferedImage image = ImageIO.read(new File(srcImagePath));
			//根据xy点坐标绘制闭合多边形
			Graphics2D g2d = image.createGraphics();
			g2d.setColor(polygonColor);
			//设置透明度
			AlphaComposite ac = AlphaComposite.getInstance(AlphaComposite.SRC_OVER, alpha);
			g2d.setComposite(ac);
			g2d.fillPolygon(xPoints, yPoints, nPoints);
			fos = new FileOutputStream(toPath);
			ImageIO.write(image, imageFormat, fos);
			g2d.dispose();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if (fos != null) {
				fos.close();
			}
		}
	}

}
